import { ipcMain, IpcMainInvokeEvent } from 'electron';
import { IpcHandler } from '../types';

/**
 * IPC 通信管理类
 */
export class IpcManager {
  /**
   * 已注册的 IPC 处理器
   */
  private handlers: Map<string, IpcHandler> = new Map();
  
  /**
   * 创建 IPC 管理器
   */
  constructor() {
    // 无需额外初始化
  }
  
  /**
   * 注册 IPC 处理器
   * @param namespace 命名空间
   * @param handler 处理器对象
   */
  public registerHandler(namespace: string, handler: IpcHandler): void {
    if (this.handlers.has(namespace)) {
      console.warn(`IPC 命名空间 "${namespace}" 已存在，将被覆盖`);
    }
    
    this.handlers.set(namespace, handler);
    
    // 注册每个方法
    for (const [methodName, method] of Object.entries(handler)) {
      const channelName = `${namespace}:${methodName}`;
      
      // 使用 ipcMain.handle 注册方法
      ipcMain.handle(channelName, async (_event: IpcMainInvokeEvent, ...args: any[]) => {
        try {
          return await method(...args);
        } catch (error) {
          console.error(`IPC 调用错误 [${channelName}]:`, error);
          throw error;
        }
      });
      
      console.log(`已注册 IPC 方法: ${channelName}`);
    }
  }
  
  /**
   * 移除 IPC 处理器
   * @param namespace 命名空间
   */
  public removeHandler(namespace: string): void {
    const handler = this.handlers.get(namespace);
    if (!handler) {
      return;
    }
    
    // 移除每个已注册的方法
    for (const methodName of Object.keys(handler)) {
      const channelName = `${namespace}:${methodName}`;
      ipcMain.removeHandler(channelName);
      console.log(`已移除 IPC 方法: ${channelName}`);
    }
    
    this.handlers.delete(namespace);
  }
  
  /**
   * 获取已注册的所有命名空间
   */
  public getNamespaces(): string[] {
    return Array.from(this.handlers.keys());
  }
  
  /**
   * 获取指定命名空间的处理器
   * @param namespace 命名空间
   */
  public getHandler(namespace: string): IpcHandler | undefined {
    return this.handlers.get(namespace);
  }
  
  /**
   * 获取所有已注册的方法名称
   */
  public getMethods(): string[] {
    const methods: string[] = [];
    
    for (const [namespace, handler] of this.handlers.entries()) {
      for (const methodName of Object.keys(handler)) {
        methods.push(`${namespace}:${methodName}`);
      }
    }
    
    return methods;
  }
  
  /**
   * 生成 TypeScript 类型定义
   */
  public generateTypeDefinitions(): string {
    let typeDefs = `/**\n * 自动生成的 Boltron IPC 类型定义\n */\n\n`;
    
    typeDefs += `// 主进程 API 类型\nexport interface MainApi {\n`;
    
    for (const [namespace, handler] of this.handlers.entries()) {
      for (const methodName of Object.keys(handler)) {
        typeDefs += `  '${namespace}:${methodName}': (...args: any[]) => Promise<any>;\n`;
      }
    }
    
    typeDefs += `}\n\n`;
    
    typeDefs += `// 渲染进程 API 类型\nexport interface RendererApi {\n`;
    
    for (const [namespace, handler] of this.handlers.entries()) {
      typeDefs += `  ${namespace}: {\n`;
      
      for (const methodName of Object.keys(handler)) {
        typeDefs += `    ${methodName}: (...args: any[]) => Promise<any>;\n`;
      }
      
      typeDefs += `  };\n`;
    }
    
    typeDefs += `}\n`;
    
    return typeDefs;
  }
} 